JudoAdditions / Web SDK

Creating a payment using a OneUseToken has been deprecated and will no longer be updated. See, Authentication Methods

The earlier version of Judopay's Web SDK was also previously known as JudoAdditions. JudoAdditions has been deprecated, however we have made it a simple implementation for you to upgrade and integrate 3D Secure 2 within your payment flow, using the latest version of our Web SDK.

For more details, see Creating a 3D Secure 2 Payment with the Web SDK

Web SDK Version 0.0.29 (and higher) fully supports 3D Secure 1 and 3D Secure 2 flows. No additional support is required, the SDK does the rest.

Make sure your account has 3D Secure 2 enabled. Contact ​Customer Support​​ to set this up.

Use Judopay's Web SDK to create a payment using a One Use Token.

The one-use token is a different field to the cardtoken.
The one-use token does not authorise any transactions but generates a oneTimeUse token for you to issue a payment request to our API endpoints, or to use our Server SDKs to request payment.

To create a one-use token:

1. Your consumer clicks the Pay button on your website.

2. Use your JudoPay instance to generate a one-use token from the card details fields: judo.createToken(payment);

   1. An encrypted Payload is generated (Judopay will decrypt the payload).

{    
"oneUseToken": "2uhOsi...8KZcn=",     
"cardLastfour": "3436",       
"endDate": "12/20",        
"cardScheme": "Visa",          
"cardFunding": "Debit",            
"error": false,        
"clientDetails": 0 
}

{   
"error":     {       
"message": "Sorry, we're unable to process your request. Please check your details and try again."   
}
}

3. The one-use token will be valid for 30 minutes .

4. Use this token to call our Transaction API and process a transaction.

5. You will need to include the one-use token as part of an encrypted card model instance.

Registering a Card for a One Use Token

Using your Judopay API client instance:

1. Create a RegisterEncryptedCardModel to save the consumer's card to Judopay’s card vault:

   var encryptedCard = new RegisterEncryptedCardModel
   {
       OneUseToken = oneUseToken,
       JudoId = judoId,
       YourConsumerReference = yourConsumerReference,
   };
   
   var response = client.RegisterCards.Create(encryptedCard);
   var receipt = response.Response as PaymentReceiptModel;
   
   if(receipt.Result === "Success") {
       var cardToken = receipt.CardDetails.CardToken;  
   }

2. The response will include a card token, which does not expire.

3. The card token can be used in a TokenPaymentModel for the next transaction.

Making a Transaction with a One Use Token

1. Using your Judopay API client instance, create a OneTimePaymentCardModel and immediately process a payment with the one-use token.

2. The response includes a card token:

   var oneTimePayment = new OneTimePaymentModel
   {
       OneUseToken = oneUseToken,
       JudoId = judoId,
       YourConsumerReference = yourConsumerReference,
       YourPaymentReference = yourPaymentReference,
       Amount: 1.0,
       Currency: "GBP"
   };
   
   var response = client.Payments.Create(oneTimePayment);
   var receipt = response.Response as PaymentReceiptModel;
   
   if(receipt.Result === "Success") {
       var cardToken = receipt.CardDetails.CardToken;  
   }

3. Save the card token for the next transaction

4. If 3D Secure is enabled, the response message = Requires 3D Secure 

All fields required to run the 3D Secure check will be available in the receipt:

• acsUrl

• PaReq

• MD

{
    "receiptId": "415874660497166336",
    "result": "Requires 3D Secure",
    "message": "Issuer authentication required",
    "acsUrl": "https://gw1.paymentsensegateway.com:4430/ACS/Default.aspx",
    "md": "1902...2484",
    "paReq": "eJxd...kqXcvg=="
}

To complete the transaction the 3D Secure form needs to be displayed to the consumer.

This can be achieved in any of the following ways: 

• a redirect

• pop-up window

• iframe

Handling 3D Secure 1.0 Payment Flows

Handling 3D Secure 1.0 payment flows has been deprecated and will no longer be updated. See, Creating a Payment with the Web SDK

The following guide is a full working example for use with Judopay's Web SDK, including how to handle 3D Secure Version 1.0 payment flows.

Prerequisites

Judopay's Web SDK requires some additional processing steps, in order to achieve a successful 3D Secure version 1.0 transaction.

This guide assumes the following prerequisites:   

• You are already using Judopay's Web SDK to process standard payments.

• You have a Judopay Sandbox Account to process test transactions while developing your app.

The sample code uses PHP to directly call our API, however this can also be used as a guide in understanding how to call our API's by other methods.

Payment Flow - 3D Secure 1.0

{oneUseToken:
"F4e7PxeRZLA31G98SfcQcIlxPR8LtC8nBpFt1CDUV1JcSOHK56",
cardLastfour: "7521",
endDate: "12/21",
cardScheme: "Visa",
cardFunding: "Credit"}

{receiptId: "614040999953559552",
                                                                            
result: "Requires 3D Secure",
                                                                            
message: "Issuer authentication
                                                                            
required",
                                                                            
acsUrl:
                                                                            
"https://gw1.judocommerce.com:4430/ACS/Default.aspx",
                                                                            
md: "200821101926255601402655",
                                                                            
paReq:
                                                                            
"encryptedPaReqMessageWillBeHere",
                                                                            
result: "Requires 3D Secure"}

$receiptId =
  $_GET['receiptId'];
  // Set the receiptID = the ID received back from the Issuer
  Service.
  $MD =
  $_POST['MD'];
  // Set $MD = MD Received from 3DS Issuer
  $PaRes =
  $_POST['PaRes'];
  // Set $PaRes = PaRes Received from 3DS Issuer
  $data =
  json_encode(array('Md' =>$MD,'PaRes' =>$PaRes));
  // Encode to JSON format
  $userEncode =
  base64_encode("yourAPIToken:yourAPISecret");
  // Setup base64 Encoded ID / Password for submission
  $headers =
  array(
              'Content-Type:application/json',
              'Authorization: Basic
  '.$userEncode,
              'API-Version: 5.7.1',
  );
  // Set curl headers for the correct format and API Version
  $ch =
  curl_init("https://gw1.judopay-sandbox.com/transactions/".$receiptId);
  // Initialise the Curl Options (this uses our sandbox endpoint,
  this will differ for production)
  curl_setopt($ch,
  CURLOPT_RETURNTRANSFER, true);
  // Raw return format
  curl_setopt($ch,
  CURLOPT_CUSTOMREQUEST, "PUT");
  // Set curl to PUT
  curl_setopt($ch,
  CURLOPT_POSTFIELDS,$data);
  // Set the PUT fields to the $data above
  curl_setopt($ch,
  CURLOPT_HTTPHEADER, $headers);
  // Setup Curl headers
  $response =
  curl_exec($ch);
  // Execute the curl against the Judo endpoint

{
  "receiptId":"614047134823608320",
  "yourPaymentReference":"a0b1e12",
  "type":"PreAuth",
  "createdAt":"2020-08-21T11:43:49.2501+01:00",
  "result":"Success",
  "message":"AuthCode:
  214733",
  "judoId":100183086,
  "merchantName":"wayne
  lawrence",
  "appearsOnStatementAs":"APL*/waynelawrence
  ",
  "originalAmount":"1.01",
  "amountCollected":"0.00",
  "netAmount":"1.01",
  "amount":"1.01",
  "currency":"GBP",
  "cardDetails":
  {"cardLastfour":"6891",
  "endDate":"1220",
  "cardToken":
  "lT1AakP6IkLlu8IVUBr5VDx7gcPV9VA1",
  "cardType":1,
  "cardScheme":
  "Visa",
  "cardFunding":"Credit",
  "cardCategory":"",
  "cardQualifier":0,
  "cardCountry":"FR",
  "bank":"Credit
  Industriel Et Commercial"},
  "consumer":
  {"consumerToken":"eaw3rv5Xy7wajdNt",
  "yourConsumerReference":"665e37f"},
  "device":{"identifier":"0b7fae264ee04cfba082c764169f52a5"},
  "riskScore":0,"threeDSecure":
  {"attempted":true,
  "result":"PASSED"},
  "externalBankResponseCode":"",
  "billingAddress":{}
  }

Step 1: Customise and Create the iframe to Present a Pay Button

To customise and create the Judopay Web SDK iframe:

1. Add the code snippet in your web page <HEAD>:

   script src="https://web.judopay.com/js/0.0.14/judopay.min.js"></script>

2. This example will use jQuery for a promise, so include the following in your web page <HEAD> :

   script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>

3. In your <BODY> add a <DIV> tag where you want the iframe to appear. div id="payment-iframe" width="100%"></div>

This example uses the id: payment-frame. You can use whatever id you wish.

4. In your <BODY> add a <DIV> tag where you want the errors in form entry to appear.

   For the purpose of this exercise, the class is named judopay-errors, and sets a style to be red.

• You can add any custom style you wish in your .CSS file.

• <div class="judopay-errors" style="color:red">Error Location</div>

5. In your <BODY> add a button call: submit-payment-button for the iframe submission to Judopay.

6. Set this to disabled. The iframe will enable it when the input is valid. 

7. You can apply any CSS styling you wish to this button.

<button id="submit-payment-button" name="submit-payment" disabled> Pay Now </button>

8. In your <BODY> add the following script for a minimum iframe. 

9. This example names this style configMinimum which is used when calling the iframe:

   <script>var configMinimum = {
   iframe: {
   language: "en",
           errorFieldId: 'judopay-errors',
           showCardTypeIcons: true,
           cardTypeIconRight: "10px",
           cardTypeIconTop: "-2px",
           backgroundColor: "#FFFFFF",
           layout: "compact",
           enabledPaymentMethods: ['CARD'],
           isCountryAndPostcodeVisible: false,
           errorsDisplay: "HIDE_UNDER_FIELDS",
           disableUnderline: false,
       }
   }
   </script>

For the purpose of this exercise, this sample config sets the following options for the iframe:

• Default language will be English “en” 

• iframe error field location set to “judopay-errors” as set in (4) above

• Card Icons will display when the card entry is recognised 

• iframe Background Colour is White “#FFFFFF” 

• iframe layout set to compact

• iframe accepts Credit Card Entry “[‘CARD’]”

• iframe does not show Post Code entry

• iframe Errors will not display under the fields

• iframe will underline the fields and highlight during entry

Create the iframe in a <SCRIPT> tag:

var judo = new JudoPay("yourAPIToken", true);
var payment = judo.createCardDetails('payment-iframe',configMinimum);

The iframe is created in your <SCRIPT> location.

10. Alter yourAPIToken to match your Sandbox API Token.

11. ‘true’ lets the iframe know it’s running on sandbox.

    • Set this to ‘false’ when you wish to go live and use a ‘live’ API Token. 

12. ‘payment-iframe’ is where the iframe will load as defined in step (3) above.

13. ‘configMinimum’ uses the style called configMinimum as defined in step (5(a)) above.

Step 2: Obtain the Payment Promise

Once you have an established Judopay Web SDK iframe and after the consumer has entered valid card details (the iframe handles the validation and errors of this entry), on clicking the Pay Now button (submit-payment-button) you will obtain a promise from Judopay's servers which will return a oneUseToken for use within 30 minutes to transact the payment.

This is a happy path example, and you should enhance this code with try / catch surrounds.

The following script:

1. Adds an action to the payment button.

2. Checks if the payment method is valid.

3. Calls Judopay to obtain a oneUseToken. 

4. It then proceeds to validate the result as having received a oneUseToken.

To setup a payment promise on the Pay Now button:

var paymentPromise = "";
$("#submit-payment-button").click(function(){
   if (judo.getPaymentMethod()=="CARD") {
      var paymentPromise = judo.createToken(payment);
      paymentPromise.then(function(result) {
         if (typeof result.error !== 'undefined') {
            if (typeof result.oneUseToken !== 'undefined') {
 
                      // This is where the token is sent to your back office for payment
             // request (expanded example below)
 
            }
         } 
      }
   }
}

Step 3: A oneUseToken is sent to Merchant's Server

This example expands on Step 2: Obtain the Payment Promise above, with the source code to handle the oneUseToken and then submit this to the merchant’s server.

1. Insert this quote into the sample above.

   This is where the token is sent to your back office for the payment request

2. This sample jQuery calls a php file called handle3.php which will submit the request to Judo and return the result:

   $.get("handle3.php",{myToken : result.oneUseToken}, function(data) {
   
   // Code in here to handle the result from the oneUseToken Request will be inserted
   // Here and handled in Step 5: Handle the Response from Judopay's Servers
   }
   );

Step 4: Merchant Server Sends Payment Request to Judopay

This example should be called handle3.php and is the receiving handler from the Step 3: A oneUseToken is sent to Merchant's Server section above.

This example:

• Receives a oneUseToken from the promise handler step.

• Submits a £1.00 payment request to Judopay for payment processing using API version 5.7.1

• Uses gw1.judopay-sandbox.com as the endpoint.

• For production use the production credentials (APIToken / APISecret) and the endpoint gw1.judopay.com

• Will return the JSON response received from Judopay's Servers:

<?php
header('Access-Control-Allow-Origin: *');
header('Content-Type: application/json');
 
$OneUseToken = $_GET["myToken"];
 
$userEncode = base64_encode("yourAPIToken:yourAPISecret");
$data=json_encode(
array(
'oneUseToken' =>$OneUseToken,
'yourConsumerReference' =>substr(md5(rand()), 0, 7),
'yourPaymentReference' => substr(md5(rand()), 0, 7),     
'judoId' => 'yourJudoId',
'amount' => 1.0,
'currency' => "GBP"
));
$headers = array(
Content-Type:application/json',
'Authorization: Basic '.$userEncode,
'API-Version: 5.7.1',
);
$ch = curl_init("https://gw1.judopay-sandbox.com/transactions/payments");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_POSTFIELDS,$data);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($ch);
 
echo $response;
 
?>

1. Change yourAPIToken:yourAPISecret for your API Token and your API Secret.

IMPORTANT: Do not omit the :

2. Change yourJudoId for your JudoID.

Step 5: Handle the Response from Judopay's Servers

1. Extend the handler from the Step 3: A oneUseToken is sent to Merchant's Server section, to handle the response.

This simple example just alerts a Success or Failure response:

$.get("handle3.php",{myToken : result.oneUseToken}, function(data) {
 
   if (data.result=="SUCCESS") {
     // Handle a Success Result
     var receiptId = data['receiptId'];
     // Handle a Failure, you can look the data result for further detail
     // To add other actions
     alert(‘Payment Success’ + receiptId);
   } else {
     alert(‘Payment Failed’);
   }
}
);

2. Checks if the result returned from Judopay's servers = SUCCESS.

3. If Success: Alerts Payment Success with the receiptId.

4. If NOT Success: Alerts Payment Failed.

Receipt Object - SUCCESS

From the Handle the Response from Judopay's Servers section above, the $response will either be a:

• receiptobject or

• an ERROR

which you should handle accordingly. This example just echo’s the result from Judopay's Servers.

Example: Receipt Object for a Successful Transaction:

{"receiptId":"615495218204119040",
"yourPaymentReference":"bbd5067",
"type":"Payment",
"createdAt":"2020-08-25T11:38:06.7811+01:00",
"result":"Success",
"message":"AuthCode: 058967",
"judoId":100183086,
"merchantName":"testmerchant",
"appearsOnStatementAs":"APL*/testmerchant ",
"originalAmount":"1.00",
"netAmount":"1.00",
"amount":"1.00",
"currency":"GBP",
"cardDetails":
{"cardLastfour":"6891",
   "endDate":"1220",
   "cardToken":"DgoimaGqpm8ngRKnAl7xgXvFS0zuf3JQ",
   "cardType":1,
   "cardScheme":"Visa",
   "cardFunding":"Credit",
   "cardCategory":"",
   "cardQualifier":0,
   "cardCountry":"FR",
   "bank":"Credit Industriel Et Commercial"},
"consumer":
{"consumerToken":"dQxfNBY5cddXeMhe",
   "yourConsumerReference":"3190912"
},
"riskScore":0,
"threeDSecure":
{"attempted":true,
   "result":"PASSED"},
"externalBankResponseCode":"",
"billingAddress":{}
}

Step 6: Re-Direct to the Issuer Service Challenge Screen

The source code from Step 5: Handle the Response from Judopay's Servers, will automatically submit the 3D Secure parameters to the required Issuer Service.

The consumer will be re-directed to the Issuer Service 3D Secure Challenge Screen:

Step 7: Issuer Service Return

If the consumer completes the 3D Secure challenge screen:

• The issuer service will POST a return encrypted result back to your termURL, as declared in Step 6: Re-Direct to the Issuer Service Challenge Screen,

If the consumer chooses to abandon at this stage, you will receive a no reply POST.

Step 8: Handle the Issuer 3D Secure Result

This example is the return3ds.php file as declared in the sample code from Step 5: Handle the Response from Judopay's Servers.

The following sample POSTs the returned 3D Secure response back to Judopay via an API call to the /transactions endpoint, with the given receiptId.

<?php

$receiptId = $_GET['receiptId'];

if (empty($receiptId))  {
  echo '<BR> Sorry there was an error - missing receiptId';
} else {
  $MD = $_POST['MD'];
  $PaRes = $_POST['PaRes'];
  $data = json_encode(array('Md' =>$MD,'PaRes' =>$PaRes));
  $userEncode = base64_encode("yourAPIToken:yourAPISecret");
  $headers = array(
  'Content-Type:application/json',
  'Authorization: Basic '.$userEncode,
  'API-Version: 5.7.1',
  );
  $ch = curl_init("https://gw1.judopay-sandbox.com/transactions/".$receiptId);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
  curl_setopt($ch, CURLOPT_POSTFIELDS,$data);
  curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
  $response = curl_exec($ch);
  echo $response;
}
?>

• receiptId is received from the termURL (Sent back from the Issuer 3D Secure Service).

• A simple check: If no receiptId is set = not proceed. It will just fail.

• Sets the JSON payload to send to Judopay's Servers.

• Replace: yourAPIToken:yourAPISecret with your Sandbox API Token and API Secret.

• Curl Options sets the endpoint to:

• For Sandbox: https://gw1.judopay-sandbox.com/transactions/

• For Production change to: https://gw1.judopay.com/transactions/ including the Production API Token and Production API Secret.

• This will complete or fail the transaction accordingly.

• The sample just echo’s the response received from Judopay's Servers (JSON Payload). The response will either be

  SUCCESS | DECLINED | ERROR

Step 9: Redirect the Consumer to the Appropriate Location

As a result of the receiptObject received in Step 5: Handle the Response from Judopay's Servers, you should redirect the consumer accordingly.

For example, if the result = SUCCESS redirect the consumer to the Success Page, else ERROR.

You can store any of the receiptObject details in your own back office systems for recall later.

You could store the:

1. cardToken

2. consumerToken

3. cardDetails

against the consumer's record and offer a quick checkout option for future transactions.

Using those tokens bypasses the need to enter any card details if required.

Web Payments - Version 1

Version 1 web payments integration has been deprecated and will no longer be updated.
For version 2, see, Web Payments Set Up

Web Payments (Version 1) - Transaction Request

To create a transaction request:

Request

https://api-sandbox.judopay.com/webpayments/payments

--header 'Api-Version: 6.4' \
--header 'Content-Type: application/json' \
--header 'Authorization: Basic XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX' \
--data-raw '{  
       "judoId":"100016172",
       "amount": 125.00,
       "currency": "GBP",
        "yourConsumerReference": "example_customer_reference_00001",
        "yourPaymentReference": "example_payment_reference_00001",
        "yourPaymentMetaData":{
            "invoiceNumber": "000546" ,
            "customerNumber": "ABC123456"
                },
         "clientIpAddress": "127.0.0.1",
         "clientUserAgent": "example browser 5.25"
}

For more information on the message request structure, see Request Message Structure.

Response Reference - Version 1

"postUrl": "https://pay.judopay-sandbox.com/v1",
"reference": "yth67_82nhjmf903jnmaiine…"

The reference example has an expiration time of 30 minutes.
If the transaction is not completed within this time, the transaction will Fail  and the status = Expired.

Web Payments (Version 1) - PreAuth Transaction Request

Use webpayments/preauths to reserve funds on a consumer's account.

Preauths will postpone the completion of the transaction until the goods have been delivered or the service fulfilled.

To create a preauth request:

Request:

https://api-sandbox.judopay.com/webpayments/preauths

{  
    "judoId":"958389",
    "amount":1.01,
    "yourConsumerReference":"JudoTest?0000771",
    "yourPaymentReference":"{{$guid}}",
    "currency":"GBP"
}

Response Reference - Version 1

{
"payByLinkUrl": "https://pay.karatepay.com/KDyPdg",
"postUrl": "https://pay.karatepay.com/v1",
"reference": "5QcAAAEAAAAbAAAAEAAAAHZVMqgikR_bu-hMzNlt8pHULA3kxJaF9-pulnDlTfvKusklaQ"
}

iOS Swift

iOS Swift SDK has been deprecated and will not longer be updated.
You will get the following warning when you submit your app to the Apple app store:"ITMS-90809: 
Deprecated API Usage - App updates that use UIWebView will no longer be accepted as of December 2020.
Instead, use WKWebView for improved security and reliability.

To integrate, see our new iOS SDK Integration with Judopay.

Getting started

If you haven’t chosen your integration method yet, begin by selecting your method and following the What to do next steps first.

Integrate simple and secure in-app card payments into your iOS Swift app with our Judopay SDK.

Judopay’s Out-of-the-box UI comes with built-in checks and security features, including real-time error detection, 3D Secure, data and address validation for frictionless card data capture.

This minimises PCI compliance and allows you focus on developing other areas of your app.

See our UI customization guide to learn more.

Integration Requirements

• Versions of the SDK greater or equal to 6.2.5 require Xcode 8 and Swift 3.

• Version 6.2.4 is the last version to be support Xcode 7.3.1 and Swift 2.2.

Add the Swift SDK to the top of the file where you want to use it:

Install Cocoapods with the following command: $ gem install cocoapods 

If you are not integrating using Cocoapods, please visit our guides for Carthage integration.

Add Judopay to your Podfile to integrate it into your Xcode project.

source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '8.0'
use_frameworks!
pod 'JudoKit', '~> 6.2'

Install the new pod in your project: $ pod install 

Please ensure that you always use the newly generated .xcworkspace file instead of the .xcodeproj file.

In Xcode, go to the Project Navigator called ‘Pods’, select the JudoKit target and open the tab called Build Phases.

Add a new Run Script Phase and drag it above the Compile Sources build phase.

Include the following line in the shell script: h "${PODS_ROOT}/DeviceDNA/Framework/strip-frameworks-cocoapods.sh"

Setup

To start setting up your app, please complete all the relevant integration steps in the getting started section.

By following these steps, you are ensuring that your app will be secure and frictionless for you and your customers.

If you have completed the setup section, start using Judopay’s iOS Swift SDK by adding your app’s token and secret when initializing the SDK:

var judoKitSession = JudoKit(token: token, secret: secret)

Command the SDK to communicate with sandbox environment by including the following line where the payment is initiated in the ViewController:

self.judoKitSession.sandboxed(true)

Point to the live environment

In your app’s ViewController, find and delete the following line that specifies the targeted environment:

self.judoKitSession.sandboxed(true)

Replace your sandbox API token and secret for the live API token and secret in the correspondent line.

Both credentials are located in the dashboard, under the Your apps section.

Follow our Access token and secret guide if you need help to find them.

var judoKitSession = JudoKit(token: token, secret: secret)

Ruby Server SDK

Ruby Server SDK has been deprecated and will no longer be updated.

Easily handle simple and secure payments on your back-end with the Judopay Ruby server side SDK. 

If you haven’t chosen your integration method yet, begin by selecting your method and following the What to do next steps first.

Integration Requirements

• Ruby 1.9.3 and above (including 2.0.x and 2.1.x).

• Add the following line to your application’s Gemfile: gem 'judopay'

• Once the Gemfile is set, then there are two options to finish the installation:

1. Execute the following line: $ bundle-

2. Or install it yourself as: $ gem install judopay

Setup

To start setting up your app, please complete all the relevant integration steps in the setup section.

By following these steps, you are ensuring that your app will be secure and frictionless for you and your customers.

When you have completed the setup, start using Judopay’s PHP SDK by adding your app’s token and secret when initializing the SDK:

Judopay.configure do |config| config.judo_id = 12345 config.api_token = 'your-token' 
config.api_secret = 'your-secret' 
# Set to true on production, defaults to false which is 
#the sandbox config.use_production = false
end

Remember, if you perform payments only from your backend, you should only enable the Register Card Transactions permission for your app and create a separate app for your backend with only the Make Payments permission enabled. 

Processing transactions with AmEx cards requires that your account supports it as well.

Please contact us first if you are planning to accept AmEx.

The SDK allows further configuration:

Logging

You will be able to attach a logger library to help you debug your Judopay integration.

Point to the live environment

1. In the Judopay gem, find and change the production environment setting from ‘false’ to ‘true’.

2. Replace your sandbox API token and secret for the live API token and secret in the corresponding lines.

3. Both credentials are located in the dashboard, under the Your apps section.

4. Follow our Access token and secret guide if you need help to find them.